home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / share / ghostscript / 8.64 / Resource / Init / gs_init.ps < prev    next >
Encoding:
Text File  |  2009-04-17  |  71.2 KB  |  2,210 lines
  1. % Copyright (C) 1989-2009 Artifex Software, Inc. All rights reserved.
  2. % 
  3. % This software is provided AS-IS with no warranty, either express or
  4. % implied.
  5. % 
  6. % This software is distributed under license and may not be copied,
  7. % modified or distributed except as expressly authorized under the terms
  8. % of the license contained in the file LICENSE in this distribution.
  9. % 
  10. % For more information about licensing, please refer to
  11. % http://www.ghostscript.com/licensing/. For information on
  12. % commercial licensing, go to http://www.artifex.com/licensing/ or
  13. % contact Artifex Software, Inc., 101 Lucas Valley Road #110,
  14. % San Rafael, CA  94903, U.S.A., +1(415)492-9861.
  15.  
  16. % $Id: gs_init.ps 9334 2009-01-08 09:17:18Z ghostgum $
  17. % Initialization file for the interpreter.
  18. % When this is run, systemdict is still writable.
  19.  
  20. % Comment lines of the form
  21. %    %% Replace <n> <file(s)>
  22. % indicate places where the next <n> lines should be replaced by
  23. % the contents of <file(s)>, when creating a single merged init file.
  24.  
  25. % The interpreter can call out to PostScript code.  All procedures
  26. % called in this way, and no other procedures defined in these
  27. % initialization files, have names that begin with %, e.g.,
  28. % (%Type1BuildChar) cvn.
  29.  
  30. % Interpreter library version number
  31. % NOTE: the interpreter code requires that the first non-comment token
  32. % in this file be an integer, and that it match the compiled-in version!
  33. 864
  34.  
  35. % Check the interpreter revision.
  36. dup revision ne
  37.  { (gs: Interpreter revision \() print revision 10 string cvs print
  38.    (\) does not match gs_init.ps revision \() print 10 string cvs print
  39.    (\).\n) print flush //null 1 .quit
  40.  }
  41. if pop
  42.  
  43. % Acquire userdict, and set its length if necessary.
  44. /userdict where
  45.  { pop userdict maxlength 0 eq }
  46.  { true }
  47. ifelse
  48. systemdict exch
  49.  {        % userdict wasn't already set up by iinit.c.
  50.    dup /userdict
  51.    currentdict dup 200 .setmaxlength        % userdict
  52.    .forceput            % userdict is local, systemdict is global
  53.  }
  54. if begin
  55.  
  56. % Define dummy local/global operators if needed.
  57. systemdict /.setglobal known
  58.  { true .setglobal
  59.  }
  60.  { /.setglobal { pop } bind def
  61.    /.currentglobal { false } bind def
  62.    /.gcheck { pop false } bind def
  63.  }
  64. ifelse
  65.  
  66. % Define .languagelevel if needed.
  67. systemdict /.languagelevel known not { /.languagelevel 1 def } if
  68.  
  69. % Optionally choose a default paper size other than U.S. letter.
  70. % The default page size for many devices is set at compile time to 
  71. % letter, but this can be changed to A4 although this is rarely done.  
  72. % Some devices such as bbox have a different default page size,
  73. % and should not be set to A4 or letter.
  74. % When ghostscript is used in countries that use the international
  75. % standard page size A4 rather than US letter, the page size of 
  76. % devices that default to letter or A4 can be changed by setting
  77. % DEFAULTPAPERSIZE.
  78. % /DEFAULTPAPERSIZE (a4) def
  79.  
  80. % Turn on array packing for the rest of initialization.
  81. true setpacking
  82.  
  83. % Define the old MS-DOS EOF character as a no-op.
  84. % This is a hack to get around the absurd habit of MS-DOS editors
  85. % of adding an EOF character at the end of the file.
  86. <1a> cvn { } def
  87.  
  88. % Acquire the debugging flags.
  89. currentdict /DEBUG known   /DEBUG exch def
  90.  
  91. % if DEBUG is set, set ALL of the subset debugging flags
  92. mark    % '[' isn't defined yet
  93.   /CCFONTDEBUG        % Compiled Fonts
  94.   /CFFDEBUG        % CFF Fonts
  95.   /CMAPDEBUG        % CMAP 
  96.   /DOCIEDEBUG        % CIE color
  97.   /EPSDEBUG        % EPS handling
  98.   /FAPIDEBUG        % Font API
  99.   /INITDEBUG        % Initialization
  100.   /PDFDEBUG        % PDF Interpreter
  101.   /PDFOPTDEBUG        % PDF Optimizer (Linearizer)
  102.   /PDFWRDEBUG        % PDF Writer
  103.   /SETPDDEBUG        % setpagedevice
  104.   /TTFDEBUG        % TTF Fonts
  105.   /VGIFDEBUG        % ViewGIF
  106.   /VJPGDEBUG        % ViewJPEG
  107.   /RESMPDEBUG        % Resource map
  108. counttomark array astore exch pop % ']' isn't defined yet
  109. { dup currentdict exch known DEBUG or def } forall
  110.  
  111. currentdict /PDFSTEP known /PDFSTEP exch def
  112. % if PDFSTEP is on, turn on PDFDEBUG
  113. PDFSTEP { /PDFDEBUG true def } if
  114.  
  115.   /VMDEBUG
  116.     INITDEBUG {{print mark
  117.             systemdict /level2dict known
  118.          { .currentglobal dup false .setglobal vmstatus
  119.            true .setglobal vmstatus 3 -1 roll pop
  120.            6 -2 roll pop .setglobal
  121.          }
  122.          { vmstatus 3 -1 roll pop
  123.          }
  124.         ifelse usertime 16#fffff and counttomark
  125.           { ( ) print (           ) cvs print }
  126.         repeat pop
  127.         ( ) print systemdict length (    ) cvs print
  128.         ( ) print countdictstack (  ) cvs print
  129.         ( <) print count (    ) cvs print (>\n) print flush
  130.       }}
  131.       {{pop
  132.       }}
  133.      ifelse
  134.   def
  135.  
  136. currentdict /BATCH known   /BATCH exch def
  137. currentdict /DELAYBIND known   /DELAYBIND exch def
  138. currentdict /DISKFONTS known   /DISKFONTS exch def
  139. currentdict /DOINTERPOLATE .knownget { /INTERPOLATE exch def } if
  140. currentdict /ESTACKPRINT known   /ESTACKPRINT exch def
  141. currentdict /FAKEFONTS known   /FAKEFONTS exch def
  142. currentdict /FIXEDMEDIA known   /FIXEDMEDIA exch def
  143. currentdict /FIXEDRESOLUTION known   /FIXEDRESOLUTION exch def
  144. currentdict /LOCALFONTS known   /LOCALFONTS exch def
  145. currentdict /JOBSERVER known   /JOBSERVER exch def
  146. currentdict /NOBIND known   /NOBIND exch def
  147. /.bind /bind load def
  148. NOBIND { /bind { } def } if
  149. currentdict /NOCACHE known   /NOCACHE exch def
  150. currentdict /NOCCFONTS known   /NOCCFONTS exch def
  151. currentdict /NOCIE known   /NOCIE exch def
  152. currentdict /NOPSICC known   /NOPSICC exch def
  153. currentdict /NODISPLAY known   not /DISPLAYING exch def
  154. currentdict /NOFONTMAP known   /NOFONTMAP exch def
  155. currentdict /NOFONTPATH known   /NOFONTPATH exch def
  156. currentdict /NOGC known   /NOGC exch def
  157. currentdict /NOINTERPOLATE .knownget { /INTERPOLATE exch not def } if
  158. currentdict /NOMEDIAATTRS known /NOMEDIAATTRS exch def
  159. currentdict /NOOUTERSAVE known   /NOOUTERSAVE exch def
  160. currentdict /NOPAGEPROMPT known   /NOPAGEPROMPT exch def
  161. currentdict /NOPAUSE known   /NOPAUSE exch def
  162. currentdict /NOPLATFONTS known   /NOPLATFONTS exch def
  163. currentdict /NOPROMPT known   /NOPROMPT exch def
  164. currentdict /NOTRANSPARENCY known   /NOTRANSPARENCY exch def
  165. currentdict /DOPS known   /DOPS exch def
  166. currentdict /NOSUBSTDEVICECOLORS known   /NOSUBSTDEVICECOLORS exch def
  167. % The default value of ORIENT1 is true, not false.
  168. currentdict /ORIENT1 known not { /ORIENT1 true def } if
  169. currentdict /OSTACKPRINT known   /OSTACKPRINT exch def
  170. currentdict /OUTPUTFILE known    % obsolete
  171.  { /OutputFile /OUTPUTFILE load def
  172.    currentdict /OUTPUTFILE .undef
  173.  } if
  174. currentdict /QUIET known   /QUIET exch def
  175. % DELAYSAFER is effectively the same as newer NOSAFER
  176. currentdict /DELAYSAFER known { /DELAYSAFER true def /NOSAFER true def } if
  177. /SAFER currentdict /NOSAFER known {
  178.   false
  179. } {
  180.   currentdict /SAFER known
  181.   currentdict /PARANOIDSAFER known or    % PARANOIDSAFER is equivalent
  182. }
  183. ifelse def
  184. currentdict /SHORTERRORS known   /SHORTERRORS exch def
  185. currentdict /STRICT known   /STRICT exch def
  186. currentdict /TTYPAUSE known   /TTYPAUSE exch def
  187. currentdict /WRITESYSTEMDICT known   /WRITESYSTEMDICT exch def
  188. currentdict /RENDERTTNOTDEF known /RENDERTTNOTDEF exch def
  189.  
  190. % Acquire environment variables.
  191. currentdict /DEVICE known not
  192.  { (GS_DEVICE) getenv { /DEVICE exch def } if } if
  193.  
  194. (START) VMDEBUG
  195.  
  196. % Open the standard files, so they will be open at the outermost save level.
  197. (%stdin) (r) file pop
  198. (%stdout) (w) file pop
  199. (%stderr) (w) file pop
  200.  
  201. /.currentuserparams where {
  202.   pop mark
  203.     % The Adobe implementations appear to have very large maximum
  204.     % stack sizes.  This turns out to actually make a difference,
  205.     % since some badly-behaved files include extremely long procedures,
  206.     % or construct huge arrays on the operand stack.
  207.     % We reset the stack sizes now so that we don't have to worry
  208.     % about overflowing the (rather small) built-in stack sizes
  209.     % during initialization.
  210.   /MaxDictStack 500
  211.   /MaxExecStack 5000
  212.   /MaxOpStack 65414
  213.   .dicttomark .setuserparams
  214. } if
  215.  
  216. % Define a procedure for skipping over an unneeded section of code.
  217. % This avoids allocating space for the skipped procedures.
  218. % We can't use readline, because that imposes a line length limit.
  219. /.skipeof    % <string> .skipeof -
  220.  { currentfile exch 1 exch .subfiledecode flushfile
  221.  } .bind def
  222.  
  223. % Define procedures to assist users who don't read the documentation.
  224. userdict begin
  225. /help
  226.  { (Enter PostScript commands.  '(filename) run' runs a file, 'quit' exits.\n)
  227.    print flush
  228.  } .bind def
  229. end
  230.  
  231. % Define =string, which is used by some PostScript programs even though
  232. % it isn't documented anywhere.
  233. % Put it in userdict so that each context can have its own copy.
  234. userdict /=string 256 string put
  235.  
  236. % Print the greeting.
  237.  
  238. /printgreeting
  239.  { mark
  240.    product (Ghostscript) search
  241.     { pop pop pop
  242.       (This software comes with NO WARRANTY: see the file PUBLIC for details.\n)
  243.     }
  244.     { pop
  245.     }
  246.    ifelse
  247.    (\n) copyright
  248.    (\)\n) revisiondate 10 mod revisiondate 10 idiv 10 mod (-)
  249.    revisiondate 100 idiv 10 mod revisiondate 1000 idiv 10 mod (-)
  250.    revisiondate 10000 idiv ( \()
  251.    revision 10 mod
  252.    revision 100 mod 10 idiv (.)
  253.    revision 100 idiv ( )
  254.    product
  255.    counttomark
  256.     { (%stdout) (w) file exch 0 .writecvp
  257.     } repeat pop
  258.  } .bind def
  259.  
  260. QUIET not { printgreeting flush } if
  261.  
  262. % Define a special version of def for making operator procedures.
  263. /obind {    % <name> <proc> obind <name> <oper>
  264.   1 index exch .makeoperator
  265. } .bind def
  266. /odef {        % <name> <proc> odef -
  267.   1 index exch .makeoperator def
  268. } .bind def
  269.  
  270. % Define a special version of def for storing local objects into global
  271. % dictionaries.  Like .forceput, this exists only during initialization.
  272. /.forcedef {        % <key> <value> .forcedef -
  273.   1 .argindex pop    % check # of args
  274.   currentdict 3 1 roll .forceput
  275. } .bind odef
  276.  
  277. % Define procedures for accessing variables in systemdict and userdict
  278. % regardless of the contents of the dictionary stack.
  279. /.systemvar {        % <name> .systemvar <value>
  280.   //systemdict exch get
  281. } .bind odef
  282. /.userdict {        % - .userdict <dict>
  283.   /userdict .systemvar
  284. } .bind odef
  285. /.uservar {        % <name> .uservar <value>
  286.   .userdict exch get
  287. } .bind odef
  288.  
  289. % If we're delaying binding, remember everything that needs to be bound later.
  290. DELAYBIND NOBIND not and
  291.  { .currentglobal false .setglobal
  292.    systemdict /.delaybind 2000 array .forceput
  293.    .setglobal
  294.    userdict /.delaycount 0 put
  295.     % When we've done the delayed bind, we want to stop saving.
  296.     % Detect this by the disappearance of .delaybind.
  297.    /bind
  298.     { /.delaybind .systemvar dup length 0 ne
  299.        { .delaycount 2 index put
  300.          .userdict /.delaycount .delaycount 1 add put
  301.        }
  302.        { pop /.bind cvx exec
  303.        }
  304.       ifelse
  305.     } .bind def
  306.  } if
  307.  
  308. %**************** BACKWARD COMPATIBILITY ****************
  309. /hwsizedict mark /HWSize //null .dicttomark readonly def
  310. /copyscanlines {        % <device> <y> <string> copyscanlines <substr>
  311.   0 3 1 roll 3 index //hwsizedict .getdeviceparams
  312.   exch pop exch pop aload pop 3 2 roll
  313.   0 exch //null exch .getbitsrect exch pop
  314. } bind odef
  315. currentdict /hwsizedict .undef
  316. /getdeviceprops
  317.  { //null .getdeviceparams
  318.  } bind odef
  319. /.putdeviceprops
  320.  { //null true counttomark 1 add 3 roll .putdeviceparams
  321.    dup type /booleantype ne
  322.     { dup mark eq { /unknown /rangecheck } if
  323.       counttomark 4 add 1 roll cleartomark pop pop pop
  324.       /.putdeviceprops .systemvar exch signalerror
  325.     }
  326.    if
  327.  } bind odef
  328. /.currentfilladjust { .currentfilladjust2 pop } bind odef
  329. /.setfilladjust { dup .setfilladjust2 } bind odef
  330. /.writecvs { 0 .writecvp } bind odef
  331. %**************** DEPRECATED PROCEDURES ****************
  332. %**************** DO NOT USE THESE IN NEW CODE ****************
  333. /max { .max } bind def        % use .max instead
  334. /min { .min } bind def        % use .min instead
  335. /unread /.unread load def    % use .peekstring instead
  336. %**************** END OF BACKWARD COMPATIBILITY SECTION ****************
  337.  
  338. % Utility for removing all entries from a dictionary
  339. /.PurgeDict   % <dict> .PurgeDict -
  340. { { true
  341.     1 index { pop exch pop false exit
  342.     } forall
  343.     { exit
  344.     } if
  345.     1 index exch undef
  346.   } loop
  347.   pop
  348. } bind def
  349.  
  350. % Define predefined procedures substituting for operators,
  351. % in alphabetical order.
  352.  
  353. userdict /#copies 1 put
  354. % Adobe implementations don't accept /[ or /], so we don't either.
  355. ([) cvn
  356.     /mark load def
  357. (]) cvn
  358.     {counttomark array astore exch pop} odef
  359. % .beginpage is redefined if setpagedevice is present.
  360. /.beginpage { } odef
  361. % In LanguageLevel 3, copypage erases the page.
  362. /copypage {
  363.     .languagelevel 3 ge
  364.     dup { 0 } { 1 } ifelse .endpage .doneshowpage {
  365.       .currentnumcopies 1 index .outputpage
  366.       (>>copypage, press <return> to continue<<\n) .confirm
  367.       dup { erasepage } if
  368.     } if pop
  369.     systemdict /..page_default_spaces .knownget { //.PurgeDict exec } if
  370.     .beginpage
  371. } odef
  372. /currentmatrix {
  373.     dup type /arraytype ne
  374.     { /currentmatrix load  /typecheck signalerror } if
  375.     dup length 6 ne
  376.     { /currentmatrix load  /rangecheck signalerror } if
  377.     .currentmatrix 6 .argindex astore pop
  378. } odef
  379. % .currentnumcopies is redefined in Level 2.
  380. /.currentnumcopies { #copies } odef
  381. /setcolorscreen where { pop        % not in all Level 1 configurations
  382.    /currentcolorscreen
  383.     { .currenthalftone
  384.        { { 60.0 exch 0.0 exch 3 copy 6 copy }    % halftone - not possible
  385.          { 3 copy 6 copy }            % screen
  386.          { }                % colorscreen
  387.        }
  388.       exch get exec
  389.     } odef
  390. } if
  391. /currentscreen
  392.     { .currenthalftone
  393.        { { 60.0 exch 0.0 exch }            % halftone - not possible
  394.          { }                % screen
  395.          { 12 3 roll 9 { pop } repeat }    % colorscreen
  396.        }
  397.       exch get exec
  398.     } odef
  399. /.echo /echo load def
  400. userdict /.echo.mode true put
  401. /echo    {dup /.echo.mode exch store .echo} odef
  402. /.eexec_param_dict mark
  403.   /eexec true
  404.   /seed 55665
  405. .dicttomark readonly def
  406. /eexec {
  407.     % Rebind .currentresourcefile if it is the source for the eexec.
  408.   dup //.eexec_param_dict //filterdict /eexecDecode get exec
  409.   cvx exch .currentresourcefile eq
  410.   //systemdict begin { {exec} .execasresource } { exec } ifelse
  411.     % Only pop systemdict if it is still the top element,
  412.     % because this is apparently what Adobe interpreters do.
  413.   currentdict //systemdict eq { end } if
  414. } odef
  415. % .endpage is redefined if setpagedevice is present.
  416. /.endpage { 2 ne } odef
  417. % erasepage mustn't use gsave/grestore, because we call it before
  418. % the graphics state stack has been fully initialized.
  419. /erasepage
  420.     { /currentcolor where
  421.        { pop currentcolor currentcolorspace { setcolorspace setcolor } }
  422.        { /currentcmykcolor where
  423.           { pop currentcmykcolor { setcmykcolor } }
  424.           { currentrgbcolor { setrgbcolor } }
  425.          ifelse
  426.        }
  427.       ifelse
  428.           currentoverprint false setoverprint 1 setgray .fillpage setoverprint
  429.           exec
  430.     } odef
  431. % To satisfy the Genoa FTS, executive must be a procedure, not an operator.
  432. /executive
  433.     { { prompt
  434.          { (%statementedit) (r) .systemvmfile } stopped
  435.          { pop pop $error /errorname get /undefinedfilename eq
  436.         { .clearerror exit } if        % EOF
  437.            /handleerror .systemvar exec //null        % ioerror??
  438.          }
  439.         if
  440.         cvx { .runexec } execute
  441.       } loop
  442.     } bind def
  443. /filter
  444.     { //filterdict 1 .argindex .knownget
  445.        { exch pop exec }
  446.        { /filter .systemvar /undefined signalerror }
  447.       ifelse
  448.     } odef
  449. % handleerror procedure as mentioned in the "Operators" section of the PLRM Section 8.2
  450. % This invokes the handleerror procedure from errordict (unless we are running under a
  451. % JOBSERVER where we want to always use a defined error handler (many error handlers in
  452. % 'wild' PostScript files are broken and don't indicate the error in any useful fashion).
  453. %
  454. % We run the handleerror procedure using .internalstopped so that broken error handlers
  455. % won't cause nested errors (Unexpected Error conditions).
  456. /handleerror
  457.     JOBSERVER {
  458.       { /.GShandleerror .systemvar .internalstopped pop } bind % always use .GShandleerror.
  459.     } {
  460.       { /errordict .systemvar /handleerror get .internalstopped pop } bind % PLRM standard errorhandling
  461.     } ifelse def
  462. /identmatrix [1.0 0.0 0.0 1.0 0.0 0.0] readonly def
  463. /identmatrix {
  464.     dup type /arraytype ne { /identmatrix load  /typecheck signalerror } if
  465.     dup length 6 ne { /identmatrix load  /rangecheck signalerror } if
  466.     dup 0 //identmatrix putinterval
  467. } odef
  468. /languagelevel 1 def        % gs_lev2.ps may change this
  469. /makeimagedevice { false makewordimagedevice } odef
  470. /matrix    { 6 array identmatrix } odef
  471. % .promptmsg is redefined if the interpreter includes readline support.
  472. /.promptmsg {
  473.     (GS) print
  474.     count 0 ne { (<) print count =only } if
  475.     (>) print flush
  476. } bind def
  477. /prompt    { flush flushpage NOPROMPT not { .promptmsg } if } bind def
  478. /pstack    { 0 1 count 3 sub { index == } for } bind def
  479. /putdeviceprops
  480.     { .putdeviceprops { erasepage } if } odef
  481. /quit    { /quit load 0 .quit } odef
  482. /run    { dup type /filetype ne { (r) .systemvmfile } if
  483.         % We must close the file when execution terminates,
  484.         % regardless of the state of the stack,
  485.         % and then propagate an error, if any.
  486.       cvx null {.runexec} .errorexec
  487.     } odef
  488. % Execute a file.
  489. % Level 2 uses 2 .stop to clear the e-stack for a successful startjob:
  490. % we detect that here, since we need to handle this even if we start out
  491. % without job control in effect.
  492. %
  493. % What we push on the e-stack is the following to be executed in this order:
  494. %    <lit-file|fileproc> .runexec1 <lit-file|fileproc> .runexec2
  495. /.runexec1 {        % <file|fileproc> .runexec1 -
  496.   dup type /filetype ne { cvx exec } if
  497.   cvx //null 2 .stopped
  498.     % If we got back here from a startjob, just keep going.
  499.     % startjob replaces the null on the o-stack with a procedure
  500.     % to be executed when we get back here.
  501.   dup //null ne { exec true } { pop false } ifelse
  502. } bind def
  503. /.runexec2 {        % <continue> <file|fileproc> .runexec2 -
  504.   exch {
  505.     .runexec
  506.   } {
  507.     dup type /filetype ne { cvx exec } if
  508.     closefile
  509.   } ifelse
  510. } bind def
  511. /.runexec {        % <file|fileproc> .runexec -
  512.   cvlit /.runexec1 cvx 1 index /.runexec2 cvx 4 .execn
  513. } bind def
  514. % The following is only for compatibility with Adobe interpreters.
  515. /setdash {
  516.     0 .argindex type dup /integertype eq exch /realtype eq or not {
  517.       /setdash .systemvar /typecheck signalerror
  518.     } if
  519.     1 .argindex length 11 gt { /setdash .systemvar /limitcheck signalerror } if
  520.     //setdash
  521. } odef
  522. /setdevice
  523.   {
  524.     .setdevice
  525.       {
  526.         mark
  527.           {         % Reset the halftone since the device may differ
  528.             currenthalftone
  529.             dup type /dicttype eq
  530.               { sethalftone }
  531.               { pop }
  532.             ifelse
  533.           }
  534.         stopped
  535.         cleartomark
  536.         erasepage
  537.       }
  538.     if
  539.   }
  540. odef
  541. /setlinecap {
  542.     dup 2 gt { /setlinecap .systemvar /rangecheck signalerror } if
  543.     .setlinecap
  544. } odef
  545. /setlinejoin {
  546.     dup 2 gt { /setlinejoin .systemvar /rangecheck signalerror } if
  547.     .setlinejoin
  548. } odef
  549. /setmatrix {
  550.     dup type /arraytype ne {
  551.       dup type /packedarraytype ne {
  552.         /setmatrix load  /typecheck signalerror
  553.       } if
  554.     } if
  555.     dup length 6 ne { /setmatrix load  /rangecheck signalerror } if
  556.     dup aload pop .setmatrix pop
  557. } odef
  558. /showpage {
  559.     0 .endpage .doneshowpage {
  560.       .currentnumcopies true .outputpage
  561.       (>>showpage, press <return> to continue<<\n) .confirm
  562.       initgraphics
  563.           currentoverprint false setoverprint 1 setcolor
  564.           .fillpage
  565.           setoverprint 0 setcolor
  566.     }
  567.     { initgraphics } ifelse
  568.     systemdict /..page_default_spaces .knownget { //.PurgeDict exec } if
  569.     .beginpage
  570. } odef
  571. % Code output by Adobe Illustrator relies on the fact that
  572. % `stack' is a procedure, not an operator!!!
  573. /stack    { 0 1 count 3 sub { index = } for } bind def
  574. /start    { BATCH { //null 0 .quit } { executive } ifelse } def
  575. % Internal uses of stopped that aren't going to do a stop if an error occurs
  576. % should use .internalstopped to avoid setting newerror et al.
  577. /.internalstopped { //null 1 .stopped //null ne } bind def
  578. /store {    % Don't alter operands before completing.
  579.     1 .argindex where { 2 index 2 index put pop pop } { def } ifelse
  580. } odef
  581. /.typenames mark .typenames counttomark packedarray exch pop def
  582. /type {
  583.     //.typenames .type
  584. } odef
  585. currentdict /.typenames .undef
  586. % When running in Level 1 mode, this interpreter is supposed to be
  587. % compatible with PostScript "version" 54.0 (I think).
  588. /version (54.0) readonly def
  589. /.wheredict 10 dict def
  590. /.where /where load def
  591. /where {
  592.     //.wheredict 1 .argindex .knownget { exec } { .where } ifelse
  593. } odef
  594.  
  595. % internaldict is defined in systemdict, but the dictionary is allocated
  596. % in local VM.  However, the procedure must be global, since it is an
  597. % "operator" and must be bind-able into global procedures.
  598. % We make a procedure for creating it, since we must create a new one
  599. % for each context with private local VM.
  600. /.makeinternaldict {
  601.   .currentglobal true .setglobal
  602.     [ /dup .systemvar 1183615869 /eq .systemvar
  603.     [ /pop .systemvar //null ] cvx
  604.     false .setglobal
  605.     dup 1 10 dict .forceput    % proc is global, dict is local
  606.     true .setglobal
  607.     [ /internaldict /cvx .systemvar /invalidaccess /signalerror cvx ] cvx
  608.       /ifelse .systemvar
  609.     ] cvx executeonly
  610.   exch .setglobal
  611. } odef
  612. systemdict /internaldict dup .makeinternaldict .makeoperator
  613. .forceput        % proc is local, systemdict is global
  614.  
  615. % Define some additional built-in procedures (beyond the ones defined by
  616. % the PostScript Language Reference Manual).
  617. % Warning: these are not guaranteed to stay the same from one release
  618. % to the next!
  619. /concatstrings    %    (str1) (str2) concatstrings (str1str2)
  620.     { exch dup length 2 index length add string    % str2 str1 new
  621.       dup dup 4 2 roll copy        % str2 new new new1
  622.       length 4 -1 roll putinterval
  623.     } bind def
  624. /copyarray
  625.     { dup length array copy } bind def
  626. % Copy a dictionary per the Level 2 spec even in Level 1.
  627. /.copydict        % <fromdict> <todict> .copydict <todict>
  628.     { dup 3 -1 roll { put dup } forall pop } bind def
  629. /copystring
  630.     { dup length string copy } bind def
  631. /findlibfile {
  632.   .systemvmlibfile { dup .filename pop exch true } { false } ifelse
  633. } odef
  634. /.growdictlength    % get size for growing a dictionary
  635.     { length 3 mul 2 idiv 1 add
  636.     } bind def
  637. /.growdict        % grow a dictionary
  638.     { dup .growdictlength .setmaxlength
  639.     } bind def
  640. /.growput        % put, grow the dictionary if needed
  641.     { 2 index length 3 index maxlength eq
  642.        { 3 copy pop known not { 2 index .growdict } if
  643.        } if
  644.       put
  645.     } bind def
  646. % .localvmarray may be an operator: see zsysvm.c.
  647. /.localvmarray where {
  648.   pop
  649. } {
  650.   /.localvmarray {
  651.     .currentglobal false .setglobal
  652.     exch array exch .setglobal
  653.   } bind def
  654. } ifelse
  655. /.localvmdict where {
  656.   pop
  657. } {
  658.   /.localvmdict {
  659.     .currentglobal false .setglobal
  660.     exch dict exch .setglobal
  661.   } bind def
  662. } ifelse
  663. /.packtomark
  664.     { counttomark packedarray exch pop } bind def
  665. /ppstack
  666.     { 0 1 count 3 sub { index === } for } bind def
  667. /runlibfile
  668.     {        % We don't want to bind 'run' into this procedure,
  669.              % since run may get redefined.
  670.       findlibfile
  671.        { exch pop /run .systemvar exec }
  672.        { /undefinedfilename signalerror }
  673.       ifelse
  674.     } bind def
  675. /selectdevice
  676.     { finddevice setdevice .setdefaultscreen } bind def
  677. /signalerror        % <object> <errorname> signalerror -
  678.     { /errordict .systemvar exch get exec } bind def
  679. /signaloperror {    % <object> <errorname> signaloperror -
  680.     % Same as signalerror, except that if we are inside a pseudo-operator
  681.     % or .errorexec, we use its error object, just as errors generated by
  682.     % real operators do.
  683.     /errordict .systemvar exch get
  684.     .finderrorobject { 3 -1 roll pop exch } if
  685.     exec
  686. } bind def
  687.  
  688. % Define the =[only] procedures.  Also define =print,
  689. % which is used by some PostScript programs even though
  690. % it isn't documented anywhere.
  691. /write=only {
  692.     .writecvs
  693. } bind def
  694. /write= {
  695.     1 index exch write=only (\n) writestring
  696. } bind def
  697. /=only    { (%stdout) (w) file exch write=only } bind def
  698. /=    { =only (\n) print } bind def
  699. /=print    /=only load def
  700. % Temporarily define == as = for the sake of runlibfile0.
  701. /== /= load def
  702.  
  703. % The following procedures are documented.
  704. /copydevice {        % <device> copydevice <newdevice>
  705.   false .copydevice2
  706. } odef
  707. /finddevice {        % <devicename> finddevice <device>
  708.   /devicedict .systemvar exch get
  709.   dup 1 get //null eq {
  710.         % This is the first request for this type of device.
  711.         % Create a default instance now.
  712.         % Stack: [proto null]
  713.     .currentglobal true .setglobal exch
  714.     dup dup 0 get copydevice 1 exch put
  715.     exch .setglobal
  716.   } if 1 get
  717. } bind def
  718. /findprotodevice {    % <devicename> findprotodevice <protodevice>
  719.   /devicedict .systemvar exch get 0 get
  720. } bind def
  721.  
  722. % Run a resource file.  This allows us to distinguish resource objects
  723. % from objects coming from input files.
  724. userdict /.currentresourcefile //null put
  725. /.execasresource {    % <file> <proc|runfile> .execasresource -
  726.   /stopped .systemvar
  727.   /.currentresourcefile .uservar
  728.         % Stack: file proc -stopped- currfile
  729.   .userdict /.currentresourcefile 5 index cvlit put
  730.   2 .execn        % stopped <file>
  731.   .userdict /.currentresourcefile 3 -1 roll put
  732.   { stop } if
  733. } bind def
  734. /.runresource {        % <file> .runresource -
  735.   { /run .systemvar exec } .execasresource
  736. } bind def
  737.  
  738. % Define procedures for getting and setting the current device resolution.
  739.  
  740. /gsgetdeviceprop    % <device> <propname> gsgetdeviceprop <value>
  741.  { 2 copy mark exch //null .dicttomark .getdeviceparams
  742.    dup mark eq        % if true, not found
  743.     { pop dup /undefined signalerror }
  744.     { 5 1 roll pop pop pop pop }
  745.    ifelse
  746.  } bind def
  747. /gscurrentresolution    % - gscurrentresolution <[xres yres]>
  748.  { currentdevice /HWResolution gsgetdeviceprop
  749.  } bind def
  750. /gssetresolution    % <[xres yres]> gssetresolution -
  751.  { 2 array astore mark exch /HWResolution exch
  752.    currentdevice copydevice putdeviceprops setdevice
  753.  } bind def
  754.  
  755. % Define auxiliary procedures needed for the above.
  756. /shellarguments        % -> shell_arguments true (or) false
  757.     { /ARGUMENTS where
  758.        { /ARGUMENTS get dup type /arraytype eq
  759.           { aload pop /ARGUMENTS //null store true }
  760.           { pop false }
  761.          ifelse }
  762.        { false } ifelse
  763.     } bind def
  764. /.confirm {
  765.   DISPLAYING NOPAUSE not TTYPAUSE or and {
  766.     % Print a message (unless NOPAGEPROMPT or NOPROMPT is true)
  767.     % and wait for the user to type something.
  768.     % If the user just types a newline, flush it.
  769.     NOPAGEPROMPT NOPROMPT or { pop } { print flush } ifelse
  770.     .confirmread
  771.   } {
  772.     pop
  773.   } ifelse
  774. } bind def
  775. /.confirmread {
  776.   TTYPAUSE {
  777.     (/dev/tty) (r) file dup read pop pop closefile
  778.   } {
  779.     .echo.mode false echo
  780.     (%stdin) (r) file dup read {
  781.       dup (\n) 0 get eq { pop pop } { unread } ifelse
  782.     } {
  783.       pop
  784.     } ifelse echo
  785.   } ifelse
  786. } bind def
  787.  
  788. % Define the procedure used by .runfile, .runstdin and .runstring
  789. % for executing user input.
  790. % This is called with a procedure or executable file on the operand stack.
  791. /.execute {        % <obj> .execute <stopped>
  792.   stopped $error /newerror get and
  793.    { /handleerror .systemvar exec flush true } { false } ifelse
  794. } bind def
  795. /execute {        % <obj> execute -
  796.   .execute pop
  797. } odef
  798. % Define an execute analogue of runlibfile0.
  799. /execute0 {        % <obj> execute0 -
  800.   .execute { /execute0 cvx 1 .quit } if
  801. } bind def
  802. % Define the procedure that the C code uses for running files
  803. % named on the command line.
  804. /.runfile {
  805.   { runlibfile } execute0
  806. } def
  807. % Define the procedure that the C code uses for running piped input.
  808. % We don't use the obvious { (%stdin) run }, because we want the file to be
  809. % reopened if a startjob does a restore.
  810. /.runstdin {
  811.   { { (%stdin) (r) file cvx } .runexec } execute0
  812. } bind def
  813. % Define the procedure that the C code uses for running commands
  814. % given on the command line with -c.  We turn the string into a file so that
  815. % .runexec can do the right thing with a startjob.
  816. /.runstring {
  817.   0 0 .systemvmstring .systemvmSFD cvx { .runexec } execute0
  818. } bind def
  819. % Define the procedure that the C code uses to set up for executing
  820. % a string that may be received in pieces.
  821. /.runstringbegin {
  822.   1 .systemvmarray dup 0 /.needinput load put cvx    % { .needinput } in systemvm
  823.   0 0 .systemvmstring .systemvmSFD cvx .runexec
  824. } bind def
  825.  
  826. % Define a special version of runlibfile that aborts on errors.
  827. /runlibfile0
  828.     { cvlit dup dup /.currentfilename exch def
  829.        { findlibfile not { stop } if }
  830.       stopped
  831.        { (Can't find \(or open\) initialization file ) print
  832.          .currentfilename == flush /runlibfile0 cvx 1 .quit
  833.        } if
  834.       exch pop cvx 
  835.       { stopped } 0 get 3 -1 roll 2 array astore cvx exec
  836.       /.currentfilename exch store
  837.        { (While reading ) print .currentfilename print (:\n) print flush
  838.          /handleerror .systemvar exec /runlibfile0 1 .quit
  839.        } if
  840.     } bind def
  841. % Temporarily substitute it for the real runlibfile.
  842. /.runlibfile /runlibfile load def
  843. /runlibfile /runlibfile0 load def
  844.  
  845. % Create the error handling machinery.
  846. % Define the standard error handlers.
  847. % The interpreter has created the ErrorNames array.
  848. /.unstoppederrorhandler    % <command> <errorname> .unstoppederrorhandler -
  849.  {    % This is the handler that gets used for recursive errors,
  850.     % or errors outside the scope of a 'stopped'.
  851.    2 copy SHORTERRORS
  852.     { (%%[ Error: ) print =only flush
  853.       (; OffendingCommand: ) print =only ( ]%%) =
  854.     }
  855.     { (Unrecoverable error: ) print =only flush
  856.       ( in ) print = flush
  857.       count 2 gt
  858.        { (Operand stack:\n  ) print
  859.          count 1 sub -1 2 { (  ) print index =only flush } for
  860.      () = flush
  861.        } if
  862.     }
  863.    ifelse
  864.    -1 0 1 //ErrorNames length 1 sub
  865.     { dup //ErrorNames exch get 3 index eq
  866.        { not exch pop exit } { pop } ifelse
  867.     }
  868.    for exch pop .quit
  869.  } bind def
  870. /.errorhandler        % <command> <errorname> .errorhandler -
  871.   {        % Detect an internal 'stopped'.
  872.     1 .instopped { //null eq { pop pop stop } if } if
  873.     (I) false .setdebug
  874.     $error /.inerror get 1 .instopped { pop } { pop true } ifelse
  875.      { .unstoppederrorhandler
  876.      } if    % detect error recursion
  877.     $error /globalmode .currentglobal false .setglobal put
  878.     $error /.inerror true put
  879.     $error /newerror true put
  880.     $error exch /errorname exch put
  881.     $error exch /command exch put
  882.     $error /errorinfo known not { $error /errorinfo //null put } if
  883.     $error /recordstacks get $error /errorname get /VMerror ne and
  884.      {        % Attempt to store the stack contents atomically.
  885.        count array astore dup $error /ostack 4 -1 roll
  886.        % Grab the execstack, then remove to two elements that are from
  887.        % this error handler (not interesting).
  888.        countexecstack array execstack dup length 2 sub 0 exch getinterval
  889.        $error /estack 3 -1 roll
  890.        countdictstack array dictstack $error /dstack 3 -1 roll
  891.        put put put aload pop
  892.      }
  893.      { $error /dstack .undef
  894.        $error /estack .undef
  895.        $error /ostack .undef
  896.      }
  897.     ifelse
  898.     $error /position currentfile status
  899.      { currentfile { fileposition } .internalstopped { pop //null } if
  900.      }
  901.      {        % If this was a scanner error, the file is no longer current,
  902.         % but the command holds the file, which may still be open.
  903.        $error /command get dup type /filetype eq
  904.         { { fileposition } .internalstopped { pop //null } if }
  905.         { pop //null }
  906.        ifelse
  907.      }
  908.     ifelse put
  909.         % During initialization, we don't reset the allocation
  910.         % mode on errors.
  911.     $error /globalmode get $error /.nosetlocal get and .setglobal
  912.     $error /.inerror false put
  913.     stop
  914.   } bind def
  915. % Define the standard handleerror.  We break out the printing procedure
  916. % (.printerror) so that it can be extended for binary output
  917. % if the Level 2 facilities are present.
  918.   /.printerror
  919.    { $error begin newerror
  920.      {
  921.        /command load errorname SHORTERRORS
  922.     { (%%[ Error: ) print =only flush
  923.       (; OffendingCommand: ) print =only
  924.       errorinfo dup //null eq {
  925.         pop
  926.       } {
  927.         (;\nErrorInfo:) print
  928.         dup type /arraytype eq
  929.           { { ( ) print =only } forall }
  930.           { ( ) print =only }
  931.         ifelse
  932.       } ifelse
  933.           ( ]%%) = flush
  934.     }
  935.     { (Error: ) print ==only flush
  936.       ( in ) print ==only flush
  937.       errorinfo dup //null eq {
  938.         pop
  939.       } {
  940.         (\nAdditional information: ) print ==only flush
  941.       } ifelse
  942.       .printerror_long
  943.     }
  944.        ifelse
  945.        .clearerror flush
  946.      }
  947.      { % newerror is false, test to see if user has set handleerror to a different
  948.        % routine, if so execute it, otherwise, just return.  This code deals with the
  949.        % Genoa issue of setting /handleerror, and then calling it, without an error
  950.        % being set.  We were erroring in this case, due to /command load failing.
  951.  
  952.         //JOBSERVER {
  953.         /errordict .systemvar /handleerror get /.GShandleerror .systemvar ne
  954.     } {
  955.         false
  956.     } ifelse
  957.          { /errordict .systemvar begin /handleerror load .internalstopped pop end
  958.          }
  959.          if
  960.      }
  961.      ifelse    % newerror 
  962.      end
  963.      flush
  964.     } bind def     
  965.   /.printerror_long            % long error printout,
  966.                     % $error is on the dict stack
  967.    {    % Push the (anonymous) stack printing procedure.
  968.     %  <heading> <==flag> <override-name> <stackname> proc
  969.        {
  970.      currentdict exch .knownget    % stackname defined in $error?
  971.      {
  972.        4 1 roll            % stack: <stack> <head> <==flag> <over>
  973.        /errordict .systemvar exch .knownget    % overridename defined?
  974.        { 
  975.          exch pop exch pop exec    % call override with <stack>
  976.        }
  977.        { 
  978.          exch print exch        % print heading. stack <==flag> <stack>
  979.          1 index not { () = } if
  980.          { 1 index { (\n    ) } { (   ) } ifelse print
  981.            dup type /dicttype eq
  982.            {
  983.          (--dict:) print
  984.          dup rcheck {
  985.            dup length =only (/) print dup maxlength =only
  986.            dup wcheck not { ((ro)) print } if
  987.          } if
  988.          /gcheck where {
  989.            pop gcheck { ((G)) } { ((L)) } ifelse print
  990.          } {
  991.            pop
  992.          } ifelse (--) print
  993.            }
  994.            {
  995.          dup type /stringtype eq 2 index or
  996.          { ==only } { =only } ifelse
  997.            } ifelse
  998.          } forall
  999.          pop
  1000.        }
  1001.        ifelse            % overridden
  1002.      }
  1003.      { pop pop pop
  1004.      }
  1005.      ifelse                % stack known
  1006.        }
  1007.  
  1008.        (\nOperand stack:) OSTACKPRINT /.printostack /ostack 4 index exec
  1009.        (\nExecution stack:) ESTACKPRINT /.printestack /estack 4 index exec
  1010.        (\nBacktrace:) true /.printbacktrace /backtrace 4 index exec
  1011.        (\nDictionary stack:) false /.printdstack /dstack 4 index exec
  1012.        () =
  1013.        pop    % printing procedure
  1014.  
  1015.        errorname /VMerror eq
  1016.     { (VM status:) print mark vmstatus
  1017.       counttomark { ( ) print counttomark -1 roll dup =only } repeat
  1018.       cleartomark () =
  1019.     } if
  1020.  
  1021.        .languagelevel 2 ge
  1022.     { (Current allocation mode is ) print
  1023.       globalmode { (global\n) } { (local\n) } ifelse print
  1024.     } if
  1025.  
  1026.        .oserrno dup 0 ne
  1027.     { (Last OS error: ) print
  1028.       errorname /VMerror ne
  1029.        { dup .oserrorstring { = pop } { = } ifelse }
  1030.        { = }
  1031.       ifelse
  1032.     }
  1033.     { pop
  1034.     }
  1035.        ifelse
  1036.  
  1037.        position //null ne
  1038.     { (Current file position is ) print position = }
  1039.        if
  1040.  
  1041.    } bind def
  1042. % Define a procedure for clearing the error indication.
  1043. /.clearerror
  1044.  { $error /newerror false put
  1045.    $error /errorname //null put
  1046.    $error /errorinfo //null put
  1047.    0 .setoserrno
  1048.  } bind def
  1049.  
  1050. % Define $error.  This must be in local VM.
  1051. .currentglobal false .setglobal
  1052. /$error 40 dict .forcedef    % $error is local, systemdict is global
  1053.         % newerror, errorname, command, errorinfo,
  1054.         % ostack, estack, dstack, recordstacks,
  1055.         % binary, globalmode,
  1056.         % .inerror, .nosetlocal, position,
  1057.         % plus extra space for badly designed error handers.
  1058. $error begin
  1059.   /newerror false def
  1060.   /recordstacks true def
  1061.   /binary false def
  1062.   /globalmode .currentglobal def
  1063.   /.inerror false def
  1064.   /.nosetlocal true def
  1065.   /position //null def
  1066.   /errorinfo //null def
  1067. end
  1068. % Define errordict similarly.  It has one entry per error name,
  1069. %   plus handleerror.  However, some astonishingly badly written PostScript
  1070. %   files require it to have at least one empty slot.
  1071. /errordict ErrorNames length 3 add dict
  1072. .forcedef        % errordict is local, systemdict is global
  1073. .setglobal        % back to global VM
  1074. % For greater Adobe compatibility, we put all non-standard errors in a
  1075. %   separate dictionary, gserrordict.  It does not need to be in local VM,
  1076. %   because PostScript programs do not access it.
  1077. %   NOTE: the name gserrordict is known to the interpreter.
  1078. /gserrordict 5 dict def
  1079. % Register an error in errordict.  We make this a procedure because we only
  1080. % register the Level 1 errors here: the rest are registered by "feature"
  1081. % files.  However, ErrorNames contains all of the error names regardless of
  1082. % what features are included, so we have to "know" that VMerror is the last
  1083. % Level 1 error.
  1084. /.registererror        % <name> .registererror -
  1085.  { errordict exch .registererror2
  1086.  } bind def
  1087. /.registererror2    % <dict> <name> .registererror -
  1088.  { .currentglobal true .setglobal    % create procs in global VM
  1089.    3 1 roll
  1090.    mark 1 index systemdict /.errorhandler get /exec load .packtomark cvx put
  1091.    .setglobal
  1092.  } bind def
  1093. ErrorNames
  1094.  { dup .registererror /VMerror eq {exit} if
  1095.  } forall
  1096. errordict begin
  1097. % The handlers for interrupt and timeout are special; there is no
  1098. % 'current object', so they push their own name.
  1099.    { /interrupt /timeout }
  1100.    { mark 1 index dup systemdict /.errorhandler get /exec load .packtomark cvx def
  1101.    } forall
  1102. /handleerror    % this key is 'well known' and some PS may redefine it
  1103.  { /.printerror .systemvar exec
  1104.  } bind def
  1105. end        % errordict
  1106.  
  1107. % Put non-standard errors in gserrordict.
  1108. gserrordict /unknownerror errordict /unknownerror get put
  1109. errordict /unknownerror .undef
  1110. % Define a stable private copy of handleerror that we will always use under
  1111. % JOBSERVER mode.
  1112. /.GShandleerror errordict /handleerror get def
  1113.  
  1114. % Define the [write]==[only] procedures.
  1115. /.dict 8 dict dup
  1116. begin def
  1117.   /.cvp {1 index exch 1 .writecvp} bind def
  1118.   /.p {1 index exch writestring} bind def
  1119.   /.p1 {2 index exch writestring} bind def
  1120.   /.p2 {3 index exch writestring} bind def
  1121.   /.print
  1122.     { dup type .dict exch .knownget { exec } { .cvp } ifelse
  1123.     } bind def
  1124.   /arraytype
  1125.     {dup rcheck
  1126.       {() exch dup xcheck
  1127.         {({) .p2
  1128.          {exch .p1
  1129.           1 index exch .print pop ( )} forall
  1130.          (})}
  1131.         {([) .p2
  1132.          {exch .p1
  1133.           1 index exch .print pop ( )} forall
  1134.          (])}
  1135.        ifelse exch pop .p}
  1136.       {.cvp}
  1137.      ifelse} bind def
  1138.   /packedarraytype /arraytype load def
  1139. {//.dict begin .print pop end}
  1140.   bind
  1141. end
  1142.  
  1143. /write==only exch def
  1144. /write== {1 index exch write==only (\n) writestring} bind def
  1145. /==only { (%stdout) (w) file exch write==only } bind def
  1146. /== {==only (\n) print} bind def
  1147.  
  1148. % Define [write]===[only], an extension that prints dictionaries
  1149. % in readable form and doesn't truncate strings.
  1150. /.dict /write==only load 0 get dup length 2 add dict .copydict dup
  1151. begin def
  1152.   /dicttype
  1153.     { dup rcheck
  1154.        { (<< ) .p1
  1155.           { 2 index 3 -1 roll .print pop ( ) .p1
  1156.         1 index exch .print pop ( ) .p
  1157.           }
  1158.          forall (>>) .p
  1159.        }
  1160.        { .cvp
  1161.        }
  1162.       ifelse
  1163.     } bind def
  1164.   /stringtype
  1165.     { 1 index exch 2 .writecvp
  1166.     } bind def
  1167.  
  1168. {//.dict begin .print pop end}
  1169.   bind
  1170. end
  1171.  
  1172. /write===only exch def
  1173. /write=== {1 index exch write===only (\n) writestring} bind def
  1174. /===only { (%stdout) (w) file exch write===only } bind def
  1175. /=== { ===only (\n) print } bind def
  1176.  
  1177. % Create the initialization queue.
  1178.  
  1179. /.delayed_init_queue 10 dict def
  1180.  
  1181. /.schedule_init   %   <priority> <proc> .schedule_init -
  1182. {
  1183.   //.delayed_init_queue 2 index known {
  1184.     (.delayed_init_queue priority conflict with ) print 1 index =
  1185.     /.schedule_init cvx /configurationerror signalerror
  1186.   } if
  1187.   //.delayed_init_queue 3 1 roll .growput
  1188. } bind def
  1189.  
  1190. /.execute_scheduled_inits %   - .execute_scheduled_inits -
  1191. {
  1192.   { 0 //null //.delayed_init_queue {     % maxp {} p {}
  1193.       3 index 2 index lt {
  1194.         4 2 roll
  1195.       } if
  1196.       pop pop
  1197.     } forall
  1198.     exch //.delayed_init_queue exch undef
  1199.     dup //null eq {
  1200.       pop exit
  1201.     } if
  1202.     exec
  1203.   } loop
  1204. } bind def
  1205.  
  1206. (END PROCS) VMDEBUG
  1207.  
  1208. % Define the font directory.
  1209. /FontDirectory false .setglobal 100 dict true .setglobal
  1210. .forcedef        % FontDirectory is local, systemdict is global
  1211.  
  1212. % Define the encoding dictionary.
  1213. /EncodingDirectory 16 dict def    % enough for Level 2 + PDF standard encodings
  1214.  
  1215. % Define .findencoding.  (This is redefined in Level 2.)
  1216. /.findencoding
  1217.  { //EncodingDirectory exch get exec
  1218.  } bind def
  1219. /.defineencoding
  1220.  { //EncodingDirectory 3 1 roll put
  1221.  } bind def
  1222. % If we've got the composite font extensions, define findencoding.
  1223. % To satisfy the Genoa FTS, findencoding must be a procedure, not an operator.
  1224. /rootfont where { pop /findencoding { .findencoding } def } if
  1225.  
  1226. % Define .registerencoding.
  1227. % NOTE: This procedure no longer does anything, but it must continue to
  1228. % exist for the sake of toolbin/encs2c.ps.
  1229. /.registerencoding {    % <index> <array> .registerencoding -
  1230.   pop pop
  1231. } bind odef
  1232.  
  1233. % Load StandardEncoding.
  1234. %% Replace 1 (gs_std_e.ps)
  1235. (gs_std_e.ps) dup runlibfile VMDEBUG
  1236.  
  1237. % Load ISOLatin1Encoding.
  1238. %% Replace 1 (gs_il1_e.ps)
  1239. (gs_il1_e.ps) dup runlibfile VMDEBUG
  1240.  
  1241. % Define stubs for the Symbol and Dingbats encodings.
  1242. % Note that the first element of the procedure must be the file name,
  1243. % since gs_lev2.ps extracts it to set up the Encoding resource category.
  1244.  
  1245.   /SymbolEncoding { /SymbolEncoding .findencoding } bind def
  1246. %% Replace 3 (gs_sym_e.ps)
  1247.   EncodingDirectory /SymbolEncoding
  1248.    { (gs_sym_e.ps) //systemdict begin runlibfile SymbolEncoding end }
  1249.   bind put
  1250.  
  1251.   /DingbatsEncoding { /DingbatsEncoding .findencoding } bind def
  1252. %% Replace 3 (gs_dbt_e.ps)
  1253.   EncodingDirectory /DingbatsEncoding
  1254.    { (gs_dbt_e.ps) //systemdict begin runlibfile DingbatsEncoding end }
  1255.   bind put
  1256.  
  1257. (END FONTDIR/ENCS) VMDEBUG
  1258.  
  1259. % Construct a dictionary of all available devices.
  1260. % These are (read-only) device prototypes that can't be
  1261. % installed or have their parameters changed.  For this reason,
  1262. % the value in the dictionary is actually a 2-element writable array,
  1263. % to allow us to create a default instance of the prototype on demand.
  1264.  
  1265.     % Loop until the .getdevice gets a rangecheck.
  1266. errordict /rangecheck 2 copy get
  1267. errordict /rangecheck { pop stop } put    % pop the command
  1268.   0 { {dup .getdevice exch 1 add} loop} .internalstopped pop
  1269.   1 add dict  /devicedict 1 index def
  1270.   begin            % 2nd copy of count is on stack
  1271.    { dup .devicename exch
  1272.      dup wcheck { dup } { //null } ifelse 2 array astore def
  1273.    } repeat
  1274.   end
  1275. put        % errordict /rangecheck
  1276. .clearerror
  1277. /devicenames devicedict { pop } forall devicedict length packedarray def
  1278.  
  1279. % Determine the default device.
  1280. /defaultdevice DISPLAYING
  1281.  { systemdict /DEVICE .knownget
  1282.     { devicedict 1 index known not
  1283.        { (Unknown device: ) print =
  1284.      flush /defaultdevice cvx 1 .quit
  1285.        }
  1286.       if
  1287.     }
  1288.     { .getdefaultdevice .devicename
  1289.     }
  1290.    ifelse
  1291.  }
  1292.  { /nullpage
  1293.  }
  1294. ifelse
  1295. /.defaultdevicename 1 index def
  1296. finddevice    % make a copy
  1297. def
  1298. devicedict /Default devicedict .defaultdevicename get put
  1299.  
  1300. (END DEVS) VMDEBUG
  1301.  
  1302. % Define statusdict, for the benefit of programs
  1303. % that think they are running on a LaserWriter or similar printer.
  1304. %% Replace 1 (gs_statd.ps)
  1305. (gs_statd.ps) runlibfile
  1306.  
  1307. (END STATD) VMDEBUG
  1308.  
  1309. % Load the standard font environment.
  1310. %% Replace 1 (gs_fonts.ps)
  1311. (gs_fonts.ps) runlibfile
  1312.  
  1313. (END GS_FONTS) VMDEBUG
  1314.  
  1315. % Define the default halftone screen and BG/UCR functions now, so that
  1316. % it will bind in the original definitions of set[color]screen.
  1317. % We make this a procedure so we can call it again when switching devices.
  1318.  
  1319. % Use an ordered dither for low-resolution devices.
  1320. /.setloreshalftone {    % <dpi> .setloreshalftone -
  1321.     % The following 'ordered dither' spot function was contributed by
  1322.     % Gregg Townsend.  Thanks, Gregg!
  1323.    16.001 div 0            % not 16: avoids rounding problems
  1324.     { 1 add 7.9999 mul cvi exch 1 add 7.9999 mul cvi 16 mul add <
  1325.     0E 8E 2E AE 06 86 26 A6 0C 8C 2C AC 04 84 24 A4
  1326.     CE 4E EE 6E C6 46 E6 66 CC 4C EC 6C C4 44 E4 64
  1327.     3E BE 1E 9E 36 B6 16 96 3C BC 1C 9C 34 B4 14 94
  1328.     FE 7E DE 5E F6 76 D6 56 FC 7C DC 5C F4 74 D4 54
  1329.     01 81 21 A1 09 89 29 A9 03 83 23 A3 0B 8B 2B AB
  1330.     C1 41 E1 61 C9 49 E9 69 C3 43 E3 63 CB 4B EB 6B
  1331.     31 B1 11 91 39 B9 19 99 33 B3 13 93 3B BB 1B 9B
  1332.     F1 71 D1 51 F9 79 D9 59 F3 73 D3 53 FB 7B DB 5B
  1333.     0D 8D 2D AD 05 85 25 A5 0F 8F 2F AF 07 87 27 A7
  1334.     CD 4D ED 6D C5 45 E5 65 CF 4F EF 6F C7 47 E7 67
  1335.     3D BD 1D 9D 35 B5 15 95 3F BF 1F 9F 37 B7 17 97
  1336.     FD 7D DD 5D F5 75 D5 55 FF 7F DF 5F F7 77 D7 57
  1337.     02 82 22 A2 0A 8A 2A AA 00 80 20 A0 08 88 28 A8
  1338.     C2 42 E2 62 CA 4A EA 6A C0 40 E0 60 C8 48 E8 68
  1339.     32 B2 12 92 3A BA 1A 9A 30 B0 10 90 38 B8 18 98
  1340.     F2 72 D2 52 FA 7A DA 5A F0 70 D0 50 F8 78 D8 58
  1341.      > exch get 256 div
  1342.     }
  1343.    bind
  1344.         % Use correct, per-plane screens for CMYK devices only.
  1345.    //systemdict /setcolorscreen known processcolors 4 eq and
  1346.     { 3 copy 6 copy //setcolorscreen }
  1347.     { //setscreen }
  1348.    ifelse
  1349. } bind def
  1350. /.setloresscreen {    % <dpi> .setloresscreen -
  1351.   .setloreshalftone
  1352.   0 array cvx settransfer    % Genoa CET won't accept a packed array!
  1353.   /setstrokeadjust where { pop true setstrokeadjust } if
  1354. } bind def
  1355. % Use a 45-degree spot screen for high-resolution devices.
  1356. % The PS3 CET insists that the screen be an array and not a packedarray (!).
  1357. currentpacking false setpacking
  1358. /.linescreen
  1359. % The following screen algorithm is used by permission of the author.
  1360.     { ((C) 1989 Berthold K.P. Horn) pop
  1361.       1 add 180 mul cos 1 0.08 add mul exch 2 add 180 mul cos 
  1362.       1 0.08 sub mul add 2 div
  1363.     }
  1364. bind readonly def
  1365. setpacking
  1366. /.sethireshalftone {    % <dpi> .sethireshalftone <doscreen>
  1367.     % According to information published by Hewlett-Packard,
  1368.     % they use a 60 line screen on 300 DPI printers and
  1369.     % an 85 line screen on 600 DPI printers.
  1370.     % However, we use a 106 line screen, which produces smoother-
  1371.     % looking shades but fewer of them (32 vs. 50).
  1372.     % 46 was suggested as a good frequency value for printers
  1373.     % between 200 and 400 DPI, so we use it for lower resolutions.
  1374.     % Imagesetters need even higher frequency screens.
  1375.    //systemdict /DITHERPPI known
  1376.     { DITHERPPI
  1377.     }
  1378.     { dup cvi 100 idiv 15 .min
  1379.        {//null 46 46 60 60 60 106 106 106 106 133 133 133 133 133 150}
  1380.       exch get
  1381.      }
  1382.    ifelse
  1383.    1 index 4.01 div .min    % at least a 4x4 cell
  1384.    45
  1385.    //.linescreen
  1386.     % Determine whether we have lots of process colors.
  1387.     % If so, don't bother with color screening or gamma correction.
  1388.     % Also don't do gamma correction on very high-resolution devices.
  1389.     % (This should depend on dot gain, not resolution, but we don't
  1390.     % currently have a way to determine this.) Ignore missing components
  1391.         % (*Values = 1).
  1392.    currentdevice mark
  1393.      /RedValues 0 /GreenValues 0 /BlueValues 0 /GrayValues 0
  1394.    .dicttomark .getdeviceparams
  1395.    counttomark 2 idiv 1 sub
  1396.     { exch pop dup 1 le
  1397.        { pop }
  1398.        { exch dup 1 le
  1399.           { pop }
  1400.           { .min }
  1401.         ifelse
  1402.        }
  1403.       ifelse
  1404.     }
  1405.    repeat
  1406.    exch pop exch pop 32 lt 4 index 800 lt and 5 1 roll
  1407.     % Stack: doscreen dpi freq angle proc
  1408.     % Ghostscript currently doesn't use correct, per-plane halftones
  1409.     % unless setcolorscreen has been executed.  Since these are
  1410.     % computationally much more expensive than binary halftones,
  1411.     % we check to make sure they are really warranted, i.e., we have
  1412.     % a high-resolution CMYK device (i.e., not a display) with
  1413.     % fewer than 5 bits per plane (i.e., not a true-color device).
  1414.    4 -1 roll 150 ge
  1415.     { /setcolorscreen where
  1416.        { pop //systemdict /COLORSCREEN known
  1417.       { COLORSCREEN }
  1418.       { 3 index }
  1419.      ifelse
  1420.      dup false ne
  1421.       { 4 1 roll 3 copy 6 copy 13 -1 roll
  1422.     % For really high-quality screening on printers, we need to
  1423.     % give each plane its own screen angle.  Unfortunately,
  1424.     % this currently has very large space and time costs.
  1425.         true eq        % true => different angles,
  1426.                 % 0 => same angles
  1427.          { { 45 90 15 75 } { 3 1 roll exch pop 12 3 roll } forall
  1428.          }
  1429.         if //setcolorscreen
  1430.       }
  1431.       { pop //setscreen    % false => single binary screen
  1432.       }
  1433.      ifelse
  1434.        }
  1435.        { //setscreen        % setcolorscreen not known
  1436.        }
  1437.       ifelse
  1438.     }
  1439.     { //setscreen            % not high resolution
  1440.     }
  1441.    ifelse
  1442. } bind def
  1443. /.sethiresscreen {    % <dpi> .sethiresscreen 
  1444.   .sethireshalftone     % pushes true if a screen halftone used
  1445.             % Stack: doscree
  1446.   {
  1447.     % Set the transfer function to lighten up the grays.
  1448.     % Parameter values closer to 1 are better for devices with
  1449.     % less dot spreading; lower values are better with more spreading.
  1450.     % The value 0.8 is a compromise that will probably please no one!
  1451.     %
  1452.     % Because of a bug in FrameMaker, we have to accept operands
  1453.     % outside the valid range of [0..1].
  1454.     {
  1455.       dup dup 0.0 gt exch 1.0 lt and
  1456.       {
  1457.         0.8 exp
  1458.       }
  1459.       if
  1460.     }
  1461.   }
  1462.   {
  1463.      % Set the transfer function to the identity.
  1464.      0 array cvx     % Genoa CET won't accept a packed array!
  1465.   }
  1466.   ifelse
  1467.   settransfer
  1468.   /setstrokeadjust where
  1469.   { pop false setstrokeadjust }
  1470.   if
  1471.  
  1472.   % Increase fill adjustment so that we effectively use Adobe's
  1473.   % any-part-of-pixel rule.
  1474.   0.5 .setfilladjust
  1475. } bind def
  1476. % Set the default screen and BG/UCR.
  1477. /.setdefaultbgucr {
  1478.   systemdict /setblackgeneration known {
  1479.     { pop 0 } dup setblackgeneration setundercolorremoval
  1480.   } if
  1481. } bind def
  1482. /.useloresscreen {    % - .useloresscreen <bool>
  1483.     % Compute min(|dpi x|,|dpi y|) as the definition of the resolution.
  1484.   72 72 matrix defaultmatrix dtransform abs exch abs .min
  1485.   dup 150 lt //systemdict /DITHERPPI known not and
  1486. } bind def
  1487.  
  1488. % The following implementation uses LL2 extensions, but only in stopped
  1489. % contexts so that with LL1, the .set??reshalftone will be used.
  1490. %
  1491. %    - .getdefaulthalftone <halftonedict> true    if default found
  1492. %                  false            
  1493. /.getdefaulthalftone {
  1494.   % try the device to see if it has a default halftone
  1495.   { currentdevice /HalftoneDefault gsgetdeviceprop } .internalstopped
  1496.   { pop pop false }        % no device property
  1497.   { dup type /dicttype eq { true } { pop false } ifelse }
  1498.   ifelse
  1499.   % stack: <halftonedict> true    if default found
  1500.   %         false          not found
  1501.   dup not
  1502.   { % device did not provide a default, try Resource
  1503.     pop { /Default /Halftone /findresource .systemvar exec } .internalstopped 
  1504.     { pop pop false } { true } ifelse
  1505.   }
  1506.   if
  1507. } bind def
  1508.  
  1509. /.setdefaulthalftone {
  1510.   .getdefaulthalftone 
  1511.   { sethalftone }
  1512.   { % default not found
  1513.     .useloresscreen { .setloreshalftone } { .sethireshalftone pop } ifelse
  1514.   }
  1515.   ifelse
  1516. } bind def
  1517.  
  1518. /.setdefaultscreen {
  1519.   .useloresscreen { .setloresscreen } { .sethiresscreen } ifelse
  1520.   .setdefaultbgucr
  1521. } bind def
  1522.  
  1523. % Rendering intent mapping for setcolorrendering1 and PDF interpreter
  1524. /.renderingintentdict mark
  1525.   /Perceptual 0
  1526.   /RelativeColorimetric 1
  1527.   /Saturation 2
  1528.   /AbsoluteColorimetric 3
  1529. .dicttomark readonly def
  1530.  
  1531. % Load basic color support
  1532. %% Replace 1 (gs_cspace.ps)
  1533. (gs_cspace.ps) runlibfile
  1534.  
  1535. (END BASIC COLOR) VMDEBUG
  1536.  
  1537.  
  1538. % Load image support
  1539. %% Replace 1 (gs_img.ps)
  1540. (gs_img.ps) runlibfile
  1541.  
  1542. (END IMAGE) VMDEBUG
  1543.  
  1544. % Auxiliary procedures for generating file name templates.
  1545.  
  1546. % Convert a path name into a string suitable for filenameforall
  1547. % For example: (a\\b*?c) to (a\\\\b\\*\\?c)
  1548. /.makepathtemplate {    % str1 -- str2
  1549.    dup length dup add string 0    % result string up to twice the size
  1550.    0 1 4 index length 1 sub {
  1551.      3 index exch get
  1552.      dup 92 eq {        % \ -> \\
  1553.         2 index 2 index 92
  1554.         put
  1555.         exch 1 add exch
  1556.      } 
  1557.      if
  1558.      dup 42 eq {        % * -> \*
  1559.         2 index 2 index 92
  1560.         put
  1561.         exch 1 add exch
  1562.      } 
  1563.      if
  1564.      dup 63 eq {        % ? -> \?
  1565.         2 index 2 index 92
  1566.         put
  1567.         exch 1 add exch
  1568.      } 
  1569.      if
  1570.      2 index 2 index 3 -1 roll put 1 add
  1571.    } for
  1572.    0 exch getinterval exch pop
  1573. } bind def
  1574.  
  1575. %   false <dir_list> <template> .generate_dir_list_templates_with_length <t1> ... <tN>
  1576. %   true  <dir_list> <template> .generate_dir_list_templates_with_length <t1> <l1> ... <tN> <ln>
  1577. %
  1578. % Generates various valid templates combining a directory list with a given template.
  1579. % With 'true' operand it also returns lengths of directory pathes.
  1580. %
  1581. % Example1 (DOS, Windows) :
  1582. %       false [(/gs/lib) (/gs/Resource/) (\gs8.00\Resource)] (*/*) -->
  1583. %       (/gs/lib/*/*) (/gs/Resource/*/*) (\\gs8.00\\Resource/*/*)
  1584. %
  1585. % Example2 (OpenVMS) :
  1586. %       false [(gs:[lib]) (gs:[Resource]) (gs800:[Resource)] (*]*) -->
  1587. %       ((gs:[lib.*]*) [gs:[Resource.*]*) ([gs800:[Resource.*]*)
  1588. %
  1589. /.generate_dir_list_templates_with_length
  1590. {                                                  % [dl] (templ)
  1591.   % We need to convert paths into templates,
  1592.   % because it can include '\' on DOS.
  1593.   % In same time, the <template> must not convert,
  1594.   % because it is already a template.
  1595.   % Besides that, we cannot combine template using .file_name_combine,
  1596.   % because template syntax breaks the platform path syntax.
  1597.   % To resolve this, we first convert the <template> into 
  1598.   % a fake filename, and combine it with path,
  1599.   % obtaining a correct separator. Then we replace
  1600.   % the fake file name with the given template.
  1601.   %
  1602.  
  1603.   % Create the fake file name :
  1604.   dup dup length string copy                       % b [dl] (templ) (ffn)
  1605.   (*) 0 get (?) 0 get (\\) 0 get (x) 0 get 0 0     % b [dl] (templ) (ffn) * ? \ x i j
  1606.   { 1 index 7 index length ge { exit } if
  1607.     6 index 2 index get                            % b [dl] (templ) (ffn) * ? \ x i j c
  1608.     dup 7 index eq                                 % b [dl] (templ) (ffn) * ? \ x i j c bool
  1609.     1 index 7 index eq or { % *?
  1610.       pop 2 index
  1611.     } if                                           % b [dl] (templ) (ffn) * ? \ x i j C
  1612.     dup 5 index eq {        % \
  1613.       3 2 roll 1 add 3 1 roll                      % b [dl] (templ) (ffn) * ? \ x i' j C
  1614.       2 index 8 index length ge { pop exit } if
  1615.       pop 6 index 2 index get                      % b [dl] (templ) (ffn) * ? \ x i' j C'
  1616.     } if
  1617.     7 index 2 index 3 2 roll put                   % b [dl] (templ) (ffn) * ? \ x i' j
  1618.     1 add exch 1 add exch                          % b [dl] (templ) (ffn) * ? \ x i'' j'
  1619.   } loop                                           % b [dl] (templ) (ffn) * ? \ x i j
  1620.   6 1 roll pop                                     % b [dl] (templ) (ffn) j * ? \ x
  1621.   exch pop exch pop exch pop exch                  % b [dl] (templ) (ffn) x j
  1622.   { dup 3 index length ge { exit } if
  1623.     3 copy exch put
  1624.     1 add
  1625.   } loop
  1626.   pop pop                                          % b [dl] (templ) (ffn)
  1627.  
  1628.   % An internal procedure : 
  1629.   {                                 % {} b [dl] (templ) (ffn) (dffn)
  1630.     dup length 
  1631.     1 sub % drop 'x', which was added above.
  1632.     exch                            % {} b [dl] (templ) (ffn) ldffn (dffn)
  1633.     .makepathtemplate               % {} b [dl] (templ) (ffn) ldffn (Dffn)
  1634.     dup                             % {} b [dl] (templ) (ffn) ldffn (Dffn) (Dffn)
  1635.     4 index length dup              % {} b [dl] (templ) (ffn) ldffn (Dffn) (Dffn) templL templL
  1636.     2 index length                  % {} b [dl] (templ) (ffn) ldffn (Dffn) (Dffn) templL templL DffnL
  1637.     exch sub                        % {} b [dl] (templ) (ffn) ldffn (Dffn) (Dffn) templL i
  1638.     exch getinterval                % {} b [dl] (templ) (ffn) ldffn (Dffn) (suffix)
  1639.     4 index exch copy pop           % {} b [dl] (templ) (ffn) ldffn (dt)
  1640.     5 index {
  1641.       exch                          % {} b [dl] (templ) (ffn) (dt) ldffn
  1642.       7 2 roll                      % (dt) ldffn {} b [dl] (templ) (ffn)
  1643.     } {
  1644.       exch pop                      % {} b [dl] (templ) (ffn) (dt)
  1645.       6 1 roll                      % (dt) {} b [dl] (templ) (ffn)
  1646.     } ifelse
  1647.   }
  1648.   5 1 roll                                         % {} b [dl] (templ) (ffn)
  1649.  
  1650.   % Generate templates :
  1651.   dup .file_name_is_absolute {
  1652.     dup                                            % {} b [dl] (templ) (ffn) (ffn)
  1653.     5 index exec                                   % (t1) {} b [dl] (templ) (ffn)
  1654.   } {
  1655.     2 index {                                      % ... {} b [dl] (templ) (ffn) (d)
  1656.       1 index                                      % ... {} b [dl] (templ) (ffn) (d) (ffn)
  1657.       false .file_name_combine {                   % ... {} b [dl] (templ) (ffn) (dffn)
  1658.         5 index exec                               % ... (t1) ?l1 {} b [dl] (templ) (ffn)
  1659.       } {                                          % ... {} b [dl] (templ) (ffn) (d) (ffn)
  1660.         pop pop                                    % ... {} b [dl] (templ) (ffn)
  1661.       } ifelse
  1662.     } forall
  1663.   } ifelse                                         % (t1) ?l1 (t2) ?l2 ... (tN) ?ln {} b [dl] (templ) (ffn)
  1664.   pop pop pop pop pop                              % (t1) ?l1 (t2) ?l2 ... (tN) ?ln
  1665. } bind def
  1666.  
  1667. %   <dir_list> <template> .generate_dir_list_templates <t1> ... <tN>
  1668. %
  1669. % Generates various valid templates combining a directory list with a given template.
  1670. % It's the 'false' case of the function above.
  1671. %
  1672. /.generate_dir_list_templates
  1673. { //false 3 1 roll //.generate_dir_list_templates_with_length exec
  1674. } bind def
  1675.  
  1676. % Load the initialization files for optional features.
  1677. %% Replace 4 INITFILES
  1678. systemdict /INITFILES known
  1679.  { INITFILES { dup runlibfile VMDEBUG } forall
  1680.  }
  1681. if
  1682.  
  1683. % If Level 2 (or higher) functionality is implemented, enable it now.
  1684. /.setlanguagelevel where {
  1685.   pop 2 .setlanguagelevel
  1686.     % If the resource machinery is loaded, fix up some things now.
  1687.   /.fixresources where { pop .fixresources } if
  1688. } if
  1689. /ll3dict where {
  1690.   pop 3 .setlanguagelevel
  1691. } if
  1692.  
  1693. (END INITFILES) VMDEBUG
  1694.  
  1695. % Create a null font.  This is the initial font.
  1696. 8 dict dup begin
  1697.   /FontMatrix [ 1 0 0 1 0 0 ] readonly def
  1698.   /FontType 3 def
  1699.   /FontName () def
  1700.   /Encoding StandardEncoding def
  1701.   /FontBBox { 0 0 0 0 } readonly def % executable is bogus, but customary ...
  1702.   /BuildChar { pop pop 0 0 setcharwidth } bind def
  1703.   /PaintType 0 def        % shouldn't be needed!
  1704. end
  1705. /NullFont exch definefont setfont
  1706.  
  1707. % Define NullFont as the font.
  1708. /NullFont currentfont def
  1709.  
  1710. % Load initial fonts from FONTPATH directories, Fontmap file,
  1711. % and/or .getccfont as appropriate.
  1712. .loadinitialfonts
  1713.  
  1714. % Remove NullFont from FontDirectory, so it can't be accessed by mistake.
  1715. /undefinefont where {
  1716.   pop /NullFont undefinefont
  1717. } {
  1718.   FontDirectory /NullFont .undef
  1719. } ifelse
  1720.  
  1721. (END FONTS) VMDEBUG
  1722.  
  1723. % Restore the real definition of runlibfile.
  1724. /runlibfile /.runlibfile load def
  1725. currentdict /.runlibfile .undef
  1726.  
  1727. % Bind all the operators defined as procedures.
  1728. /.bindoperators        % binds operators in currentdict
  1729.  { % Temporarily disable the typecheck error.
  1730.    errordict /typecheck 2 copy get
  1731.    errordict /typecheck { pop } put    % pop the command
  1732.    currentdict
  1733.     { dup type /operatortype eq
  1734.        { % This might be a real operator, so bind might cause a typecheck,
  1735.      % but we've made the error a no-op temporarily.
  1736.      .bind        % do a real bind even if NOBIND is set
  1737.        }
  1738.       if pop pop
  1739.     } forall
  1740.    put
  1741.  } def
  1742. NOBIND DELAYBIND or not { .bindoperators } if
  1743.  
  1744. % Establish a default environment.
  1745.  
  1746. defaultdevice
  1747. % The following line used to skip setting of page size and resolution if
  1748. % NODISPLAY was selected.  We think this was only to save time and memory,
  1749. % and it is a bad idea because it prevents setting the resolution in this
  1750. % situation, which pstoedit (among other programs) relies on.
  1751. %DISPLAYING not { setdevice (%END DISPLAYING) .skipeof } if
  1752.  
  1753. % If the paper size is not specifed and the device defaults to 
  1754. % letter or A4 paper, select the DEFAULTPAPERSIZE.
  1755. systemdict /DEFAULTPAPERSIZE known not 
  1756.  {
  1757.    % Use .defaultpapersize if it returns a known paper size
  1758.    .defaultpapersize 
  1759.     { 
  1760.       false statusdict /.pagetypenames get 
  1761.        {
  1762.     2 index eq { pop true exit } if
  1763.        }
  1764.       forall
  1765.        {systemdict exch /DEFAULTPAPERSIZE exch put}
  1766.        {QUIET
  1767.      { pop } 
  1768.      { (Unknown .defaultpapersize: ) print ==only (.) = }
  1769.     ifelse
  1770.        } 
  1771.       ifelse
  1772.     } 
  1773.    if
  1774.  } 
  1775. if
  1776. systemdict /DEFAULTPAPERSIZE known
  1777. systemdict /PAPERSIZE known not and
  1778. systemdict /DEVICEWIDTH known not and
  1779. systemdict /DEVICEHEIGHT known not and
  1780. systemdict /DEVICEWIDTHPOINTS known not and
  1781. systemdict /DEVICEHEIGHTPOINTS known not and
  1782.  {
  1783.    defaultdevice mark /PageSize //null .dicttomark .getdeviceparams 
  1784.    .dicttomark /PageSize get
  1785.    dup 0 get 0.5 add cvi 612 eq 1 index 1 get 0.5 add cvi 792 eq and
  1786.    1 index 0 get 0.5 add cvi 595 eq 2 index 1 get 0.5 add cvi 842 eq and
  1787.    or exch pop
  1788.    {
  1789.      % the default paper size was letter, so replace it with DEFAULTPAPERSIZE
  1790.      /PAPERSIZE DEFAULTPAPERSIZE def
  1791.    } if
  1792.  }
  1793. if
  1794.  
  1795. systemdict /DEVICEWIDTH known
  1796. systemdict /DEVICEHEIGHT known or
  1797. systemdict /DEVICEWIDTHPOINTS known or
  1798. systemdict /DEVICEHEIGHTPOINTS known or
  1799. systemdict /DEVICEXRESOLUTION known or
  1800. systemdict /DEVICEYRESOLUTION known or
  1801. systemdict /PAPERSIZE known or
  1802. not { (%END DEVICE) .skipeof } if
  1803. % Let DEVICE{WIDTH,HEIGHT}[POINTS] override PAPERSIZE.
  1804. systemdict /PAPERSIZE known
  1805. systemdict /DEVICEWIDTH known not and
  1806. systemdict /DEVICEHEIGHT known not and
  1807. systemdict /DEVICEWIDTHPOINTS known not and
  1808. systemdict /DEVICEHEIGHTPOINTS known not and
  1809.  {    % Convert the paper size to device dimensions.
  1810.    true statusdict /.pagetypenames get
  1811.     { PAPERSIZE eq
  1812.        { PAPERSIZE load
  1813.          dup 0 get /DEVICEWIDTHPOINTS exch def
  1814.          1 get /DEVICEHEIGHTPOINTS exch def
  1815.          pop false exit
  1816.        }
  1817.       if
  1818.     }
  1819.    forall
  1820.     { (Unknown paper size: ) print PAPERSIZE ==only (.) =
  1821.     }
  1822.    if
  1823.  }
  1824. if
  1825. % Adjust the device parameters per the command line.
  1826. % It is possible to specify resolution, pixel size, and page size;
  1827. % since any two of these determine the third, conflicts are possible.
  1828. % We simply pass them to .setdeviceparams and let it sort things out.
  1829.    mark /HWResolution //null /HWSize //null /PageSize //null .dicttomark
  1830.    .getdeviceparams .dicttomark begin
  1831.    mark
  1832.     % Check for resolution.
  1833.    /DEVICEXRESOLUTION where dup
  1834.     { exch pop HWResolution 0 DEVICEXRESOLUTION put }
  1835.    if
  1836.    /DEVICEYRESOLUTION where dup
  1837.     { exch pop HWResolution 1 DEVICEYRESOLUTION put }
  1838.    if
  1839.    or { /HWResolution HWResolution } if
  1840.     % Check for device sizes specified in pixels.
  1841.    /DEVICEWIDTH where dup
  1842.     { exch pop HWSize 0 DEVICEWIDTH put }
  1843.    if
  1844.    /DEVICEHEIGHT where dup
  1845.     { exch pop HWSize 1 DEVICEHEIGHT put }
  1846.    if
  1847.    or { /HWSize HWSize } if
  1848.     % Check for device sizes specified in points.
  1849.    /DEVICEWIDTHPOINTS where dup
  1850.     { exch pop PageSize 0 DEVICEWIDTHPOINTS put }
  1851.    if
  1852.    /DEVICEHEIGHTPOINTS where dup
  1853.     { exch pop PageSize 1 DEVICEHEIGHTPOINTS put }
  1854.    if
  1855.    or { /PageSize PageSize } if
  1856.     % Check whether any parameters were set.
  1857.    dup mark eq { pop defaultdevice } { defaultdevice putdeviceprops } ifelse
  1858.    end
  1859. %END DEVICE
  1860. % Set any device properties defined on the command line.
  1861. % If BufferSpace is defined but not MaxBitmap, set MaxBitmap to BufferSpace.
  1862. systemdict /BufferSpace known
  1863. systemdict /MaxBitmap known not and
  1864.  { systemdict /MaxBitmap BufferSpace put
  1865.  } if
  1866. dup getdeviceprops
  1867. counttomark 2 idiv
  1868.  { systemdict 2 index known
  1869.     { pop dup load counttomark 2 roll }
  1870.     { pop pop }
  1871.    ifelse
  1872.  } repeat
  1873. counttomark dup 0 ne
  1874.  { 2 add -1 roll putdeviceprops }
  1875.  { pop pop }
  1876. ifelse
  1877. % If the initial device parameters are invalid, the setdevice may fail.
  1878. % Trap this and produce a reasonable error message.
  1879. { setdevice }        % does an erasepage
  1880. INITDEBUG { exec false } { .internalstopped } ifelse {
  1881.   (**** Unable to open the initial device, quitting.) = flush 1 .quit
  1882. } if
  1883.  
  1884. % If the media size is fixed, update the current page device dictionary.
  1885. FIXEDMEDIA
  1886. dup { pop systemdict /.currentpagedevice known } if
  1887. dup { pop .currentpagedevice exch pop } if
  1888. not { (%END MEDIA) .skipeof } if
  1889. currentpagedevice dup length dict .copydict
  1890. dup /Policies
  1891.     % Stack: <pagedevice> <pagedevice> /Policies
  1892. 1 index /InputAttributes
  1893. 2 copy get dup length dict .copydict
  1894.     % Stack: <pagedevice> <pagedevice> /Policies <pagedevice>
  1895.     %   /InputAttributes <inputattrs'>
  1896. dup 0 2 copy get dup length dict .copydict
  1897.     % Stack: <pagedevice> <pagedevice> /Policies <pagedevice>
  1898.     %   /InputAttributes <inputattrs'> <inputattrs'> 0 <attrs0'>
  1899. dup /PageSize 7 index /PageSize get
  1900. put                % PageSize in 0
  1901. put                % 0 in InputAttributes
  1902. put                % InputAttributes in pagedevice
  1903. % Also change the page size policy so we don't get an error.
  1904.     % Stack: <pagedevice> <pagedevice> /Policies
  1905. 2 copy get dup length dict .copydict
  1906.     % Stack: <pagedevice> <pagedevice> /Policies <policies'>
  1907. dup /PageSize 7 put        % PageSize in Policies
  1908. put                % Policies in pagedevice
  1909. .setpagedevice
  1910. %END MEDIA
  1911.  
  1912. % Set up the interpreter context version of -dUSeCIEColor option
  1913. % so that .getuseciecolor has the correct value (see gs_setpd.ps)
  1914. /setpagedevice where {
  1915.   pop systemdict /UseCIEColor known {
  1916.     mark /UseCIEColor UseCIEColor .dicttomark setpagedevice
  1917.   } if
  1918. } if
  1919.  
  1920. %END DISPLAYING
  1921.  
  1922. (END DEVICE) VMDEBUG
  1923.  
  1924. % Establish a default upper limit in the character cache,
  1925. % namely, enough room for a 18-point character at the resolution
  1926. % of the default device, or for a character consuming 1% of the
  1927. % maximum cache size, whichever is larger.
  1928. mark
  1929.     % Compute limit based on character size.
  1930.   18 dup dtransform
  1931.   exch abs cvi 31 add 32 idiv 4 mul    % X raster
  1932.   exch abs cvi mul        % Y
  1933.     % Compute limit based on allocated space.
  1934.   cachestatus pop pop pop pop pop exch pop 0.01 mul cvi
  1935.   .max dup 10 idiv exch
  1936. setcacheparams
  1937. % Conditionally disable the character cache.
  1938. NOCACHE { 0 setcachelimit } if
  1939.  
  1940. (END CONFIG) VMDEBUG
  1941.  
  1942. % Initialize graphics.
  1943.  
  1944. .setdefaultscreen
  1945. initgraphics
  1946.  
  1947. % The interpreter relies on there being at least 2 entries
  1948. % on the graphics stack.  Establish the second one now.
  1949. gsave
  1950.  
  1951. % Define some control sequences as no-ops.
  1952. % This is a hack to get around problems
  1953. % in some common PostScript-generating applications.
  1954. <04> cvn JOBSERVER {
  1955.     { { clear cleardictstack //false 0 .startnewjob } 2 .stop } bind
  1956.   } {
  1957.     { }
  1958.   } ifelse def
  1959. <1b> cvn {             % UEL is <esc>%-12345X and acts the same as ^D
  1960.   currentfile (%-12345X) .peekstring pop (%-12345X) eq <04> cvn load if
  1961. } bind def
  1962. <1b45> cvn { } def        % PJL reset prologue (ESC E)
  1963. <1b451b> cvn <1b> cvn load def    % PJL reset epilogue (ESC E + UEL)
  1964. (\001M) cvn            % TBCP initiator
  1965.  { currentfile /TBCPDecode filter cvx exec
  1966.  } bind def
  1967. /@PJL                % H-P job control
  1968.  {
  1969.    % Windows 2000 driver includes PJL into %%BeginFeature block.
  1970.    % Identify this from the pattern on the stack: countdictstack lucas mark
  1971.    % and fail the feature request.
  1972.  
  1973.    count 3 ge {
  1974.      dup mark eq {
  1975.        2 index countdictstack eq {
  1976.           1 index /lucas where { /lucas get eq } { pop false } ifelse {
  1977.             stop
  1978.          } if
  1979.        } if
  1980.      } if
  1981.    } if
  1982.    currentfile //=string readline pop pop
  1983.  } bind def
  1984.  
  1985. % Install the EPS handler if needed
  1986. systemdict /EPSBoundingBoxInit known { EPSBoundingBoxInit } if
  1987.  
  1988. % If we want a "safer" system, disable some obvious ways to cause havoc.
  1989. .currentglobal true .setglobal
  1990. /SAFETY 2 dict
  1991.   dup /safe false put
  1992.   dup /tempfiles 10 dict readonly put
  1993. readonly def
  1994. .setglobal
  1995.  
  1996. /.locksafe {
  1997.   SAFETY /safe get not {
  1998.     <<
  1999.       /PermitFileReading [
  2000.         currentuserparams /PermitFileReading get aload pop
  2001.         /FONTPATH .systemvar (*) .generate_dir_list_templates
  2002.           % Library files : 
  2003.         /LIBPATH  .systemvar (*) .generate_dir_list_templates       
  2004.           % Resource files on OpenVMS requires a separate template (gs:[dir.*]*)
  2005.           % because the (gs:[dir]*) doesn't cover them.
  2006.         /LIBPATH  .systemvar (*) .file_name_separator (*)
  2007.           concatstrings concatstrings .generate_dir_list_templates
  2008.         .languagelevel 2 ge {
  2009.             % Default resources :
  2010.           [ currentsystemparams /GenericResourceDir get] (*) .generate_dir_list_templates
  2011.             % Default resources (OpenVMS, see comment above.) :
  2012.           [ currentsystemparams /GenericResourceDir get] (*) .file_name_separator (*)
  2013.             concatstrings concatstrings .generate_dir_list_templates
  2014.         } if
  2015.       ]
  2016.       /LockFilePermissions true
  2017.     >> setuserparams
  2018.   }
  2019.   if
  2020.   % setpagedevice has the side effect of clearing the page, but
  2021.   % we will just document that. Using setpagedevice keeps the device
  2022.   % properties and pagedevice .LockSafetyParams in agreement even
  2023.   % after a restore that changes the value to false.
  2024.   currentglobal currentpagedevice gcheck setglobal % use correct VM space
  2025.   << /.LockSafetyParams true >> setpagedevice
  2026.   setglobal
  2027.   //SAFETY /safe //true .forceput % overrides readonly
  2028. } .bind executeonly odef
  2029.  
  2030. /.setsafe
  2031. {
  2032.   SAFETY /safe get not {
  2033.     <<
  2034.       /PermitFileReading [ ]
  2035.       /PermitFileWriting [ ]
  2036.       /PermitFileControl [ ]
  2037.     >> setuserparams
  2038.   }
  2039.   if
  2040.   .locksafe
  2041. } .bind executeonly odef
  2042.  
  2043. /deletefile {
  2044.   dup { deletefile } stopped {
  2045.     pop //deletefile $error /errorname get signalerror
  2046.   } {
  2047.     % deletefile succeeded. Remove from tempfile list if present
  2048.     //SAFETY /tempfiles get exch cvn 2 copy known {
  2049.       .forceundef
  2050.     } {
  2051.       pop pop
  2052.     }
  2053.     ifelse
  2054.   }
  2055.   ifelse
  2056. } .bind executeonly odef
  2057.  
  2058. % If a file is opened with .tempfile with SAFER not (yet) set,
  2059. % the file can be deleted later, even if SAFER is set.
  2060. /.tempfile {
  2061.   .tempfile    % filename file
  2062.   //SAFETY /tempfiles get 2 .argindex true .forceput
  2063. } .bind executeonly odef
  2064.  
  2065. % If we are running in SAFER mode, lock things down
  2066. SAFER { .setsafe } if
  2067.  
  2068. % If we delayed binding, make it possible to do it later.
  2069. /.bindnow {
  2070.   currentuserparams /IdiomRecognition .knownget {
  2071.     1 dict dup /IdiomRecognition //false put setuserparams
  2072.   } if
  2073.   //systemdict begin .bindoperators end
  2074.   % Temporarily disable the typecheck error.
  2075.   errordict /typecheck 2 copy get
  2076.   errordict /typecheck { pop } put    % pop the command
  2077.   0 1 .delaycount 1 sub { .delaybind exch get .bind pop } for
  2078.   //systemdict /.delaybind {} .forceput    % reclaim the space
  2079.   //systemdict /.bindnow .forceundef    % ditto
  2080.   put
  2081.   //systemdict /.forcecopynew .forceundef    % remove temptation
  2082.   //systemdict /.forcedef .forceundef        % ditto
  2083.   //systemdict /.forceput .forceundef        % ditto
  2084.   //systemdict /.forceundef .forceundef        % ditto
  2085.   currentuserparams /IdiomRecognition known {
  2086.     1 dict dup /IdiomRecognition 4 -1 roll put setuserparams
  2087.   } if
  2088. } .bind odef
  2089.  
  2090. % Turn off array packing, since some PostScript code assumes that
  2091. % procedures are writable.
  2092. false setpacking
  2093.  
  2094. (END INIT) VMDEBUG
  2095.  
  2096. /.currentuserparams where {
  2097.   pop
  2098.     % Remove real user params from psuserparams.
  2099.   mark .currentuserparams counttomark 2 idiv {
  2100.     pop psuserparams exch undef
  2101.   } repeat pop
  2102.     % Update the copy of the user parameters.
  2103.   mark .currentuserparams counttomark 2 idiv {
  2104.     userparams 3 1 roll .forceput    % userparams is read-only
  2105.   } repeat pop
  2106.     % Turn on idiom recognition, if available.
  2107.   currentuserparams /IdiomRecognition known {
  2108.     /IdiomRecognition true .definepsuserparam
  2109.   } if
  2110.   psuserparams readonly pop
  2111.   systemdict /.definepsuserparam undef
  2112.     % Save a copy of userparams for use with save/restore
  2113.     % (and, if implemented, context switching).
  2114.   .currentglobal false .setglobal
  2115.      mark userparams { } forall .dicttomark readonly
  2116.      /userparams exch .forcedef        % systemdict is read-only
  2117.   .setglobal
  2118. } if
  2119. /.currentsystemparams where {
  2120.   pop
  2121.     % Remove real system params from pssystemparams.
  2122.   mark .currentsystemparams counttomark 2 idiv {
  2123.     pop pssystemparams exch .forceundef
  2124.   } repeat pop
  2125. } if
  2126.  
  2127. % Set up AlignToPixels :
  2128.  
  2129. /AlignToPixels where {
  2130.   mark /AlignToPixels 2 index /AlignToPixels get .dicttomark setuserparams
  2131.   /AlignToPixels undef
  2132. } if
  2133.  
  2134. % Set up GridFitTT :
  2135.  
  2136. /GridFitTT where {
  2137.   mark /GridFitTT 2 index /GridFitTT get .dicttomark setuserparams
  2138.   /GridFitTT undef
  2139. } if
  2140.  
  2141. % Establish local VM as the default.
  2142. false /setglobal where { pop setglobal } { .setglobal } ifelse
  2143. $error /.nosetlocal false put
  2144.  
  2145. (END GLOBAL) VMDEBUG
  2146.  
  2147. /.savelocalstate where {
  2148.     % If we might create new contexts, save away copies of all dictionaries
  2149.     % referenced from systemdict that are stored in local VM,
  2150.     % and also save a copy of the initial gstate.
  2151.   pop .savelocalstate
  2152. } {
  2153.     % If we're *not* running in a multi-context system and FAKEFONTS is
  2154.     % defined, add the fake fonts to LocalFontDirectory.
  2155.   .definefakefonts    % current VM is local
  2156. } ifelse
  2157.  
  2158. % Execute scheduled inits :
  2159. //.execute_scheduled_inits exec
  2160. currentdict /.execute_scheduled_inits undef
  2161. currentdict /.delayed_init_queue undef
  2162.  
  2163. % Make global and local FontDirectory read-only.
  2164. FontDirectory readonly pop
  2165. /GlobalFontDirectory where { pop GlobalFontDirectory readonly pop } if
  2166.  
  2167. % Remove systemdict entries for things that have been bound in where used
  2168. % and that shouldn't be accessible by name, and close up systemdict.
  2169. currentdict /filterdict .undef
  2170. currentdict /.cidfonttypes .undef
  2171. currentdict /.colorrenderingtypes .undef
  2172. currentdict /.formtypes .undef
  2173. currentdict /.halftonetypes .undef
  2174. currentdict /.imagetypes .undef
  2175. currentdict /.imagemasktypes .undef
  2176. currentdict /.patterntypes .undef
  2177. currentdict /.shadingtypes .undef
  2178. currentdict /.wheredict .undef
  2179. currentdict /.renderingintentdict .undef
  2180. end
  2181.  
  2182. % Clean up VM, and enable GC.
  2183. /vmreclaim where
  2184.  { pop NOGC not { 2 vmreclaim 0 vmreclaim } if
  2185.  } if
  2186. DELAYBIND not {
  2187.   systemdict /.forcecopynew .undef    % remove temptation
  2188.   systemdict /.forcedef .undef        % ditto
  2189.   systemdict /.forceput .undef        % ditto
  2190.   systemdict /.forceundef .undef    % ditto
  2191. } if
  2192. % Move superexec to internaldict if superexec is defined.
  2193. currentdict /superexec .knownget {
  2194.   1183615869 internaldict /superexec 3 -1 roll put
  2195.   currentdict /superexec .undef
  2196. } if
  2197. WRITESYSTEMDICT not { systemdict readonly pop } if
  2198. (END GC) VMDEBUG
  2199.  
  2200. % The Adobe AGM_Core used by Illustrator 9 has some code that breaks
  2201. % if the 'product' is not (Adobe PostScript Parser). A bug has been
  2202. % submitted to Adobe since this also fails with Acrobat Distiller.
  2203. % As a temporary work around, the following HACK will work for
  2204. % devices without spot color support. Once Ghostscript can
  2205. % support DeviceN and spot color separations this will need to
  2206. % be 'true' in some cases.
  2207. userdict /AGM_preserve_spots false put
  2208.  
  2209. % The interpreter will run the initial procedure (start).
  2210.